#/bin/bash

##########################################
# SSOO Grupo 06 - 2012, 2° Cuatrimestre  #
#         Comando InstalaW5.sh           #
##########################################

directorio=`readlink -f "${BASH_SOURCE[0]}"`
directorio=${directorio%'/'*}'/'

GRUPO="$HOME/grupo06"
CONFDIR="$GRUPO/confdir"
echo "Comando InstalaW5 Inicio de Ejecucion"
BINDIR="$GRUPO/bin"
MAEDIR="$GRUPO/mae"
ARRIDIR="$GRUPO/arribos"
DATASIZE="100"
ACEPDIR="$GRUPO/aceptados"
RECHDIR="$GRUPO/rechazados"
PROCDIR="$GRUPO/procesados"
LOGSIZE="400"
REPODIR="$GRUPO/reportes"

LOGDIR="$GRUPO/log"
LOGEXT="log"
export $LOGDIR
export $LOGEXT # para poder usar el logger

#LOGGER_EXE="perl ./BINDIR/Logger.pl" descomentar y loguear usando logger de la carpeta de instalacion!

function setVariable()
{
	variable="$1"
	valor="$2"
	sed "/^$variable/d" -i $configFile
	echo "$variable=$valor" >> $configFile
}

function setDirectorio()
{
	variable="$1"
	valor=`echo "$2" | sed 's@[^/]$@&/@'` # Agregar barra al final
	setVariable $variable $valor
}

function generarConfiguracion()
{
	echo -n > $configFile
	setDirectorio GRUPO $GRUPO
	setDirectorio CONFDIR $CONFDIR
	setDirectorio BINDIR $BINDIR
	setDirectorio MAEDIR $MAEDIR
	setDirectorio ARRIDIR $ARRIDIR
	setDirectorio RECHDIR $RECHDIR
	setDirectorio ACEPDIR $ACEPDIR
	setDirectorio PROCDIR $PROCDIR
	setDirectorio REPODIR $REPODIR
	setDirectorio LOGDIR $LOGDIR
	setVariable DATASIZE $DATASIZE
	setVariable LOGSIZE $LOGSIZE
	setVariable LOGEXT $LOGEXT
	setVariable SECUENCIA1 0
	setVariable SECUENCIA2 0
}

function mostrarDirectorio()
{
	local formato='s/^.*$/\t&/'
	ls -1 $1 | sed $formato
}

function verificarDirectorio()
{
	local directorio="$1"
	local lista="$2"
	local faltante=
	local cantidad=0
	for archivo in $lista; do
		if [ ! -e "$directorio$archivo" ]; then
			faltante=$faltante" $archivo"
			cantidad=`expr $cantidad + 1`
		fi
	done
	echo -e "\tComponentes existentes:"
	ls -1 $directorio | sed 's/^.*$/\t\t&/'
	echo -e "\tComponentes faltantes: $cantidad"
	for archivo in $faltante; do
		echo -e "\t\t$archivo"
		LOGGER_EXE -a -m="Archivo $archivo faltante." -l="InstalaW5.sh"
	done
	return $cantidad
}

function detectarInstalacion()
{
	if [ -r "$CONFDIR/InstalaW5.conf" ]; then
		echo "Se detectó una instalacion existente"
		LOGGER_EXE -a -m="Se detecto una instalacion ya existente." -l="InstalaW5.sh"
		. "$directorio"'BINDIR/leerConfig.sh' "$CONFDIR/InstalaW5.conf"
		local faltantes=0
		verificarDirectorio $BINDIR "$LISTA_BINDIR"
		faltantes=`expr $faltantes + $?`
		verificarDirectorio $MAEDIR "$LISTA_MAEDIR"
		faltantes=`expr $faltantes + $?`
		return $faltantes
	fi
	return 100
}

function mostrarConfiguracionCompleta()
{
	echo 'TP SO7508 Segundo Cuatrimestre 2012. Tema W Copyright © Grupo 06'
	LOGGER_EXE -i -m="TP SO7508 Segundo Cuatrimestre 2012. Tema W Copyright © Grupo 06." -l="InstalaW5.sh"
	echo 'Libreria del sistema: '$CONFDIR
	LOGGER_EXE -i -m="Libreria del sistema: $CONFDIR." -l="InstalaW5.sh"
	mostrarDirectorio $CONFDIR
	echo 'Ejecutables: '$BINDIR
	LOGGER_EXE -i -m="Ejecutables: $BINDIR." -l="InstalaW5.sh"
	mostrarDirectorio $BINDIR
	echo 'Archivos maestros: '$MAEDIR
	LOGGER_EXE -i -m="Archivos maestros: $MAEDIR." -l="InstalaW5.sh"
	mostrarDirectorio $MAEDIR
	echo 'Directorio de arribo de archivos externos: '$ARRIDIR
	LOGGER_EXE -i -m="Directorio de arribo de archivos externos: $ARRIDIR." -l="InstalaW5.sh"
	echo 'Archivos externos aceptados: '$ACEPDIR
	LOGGER_EXE -i -m="Archivos externos aceptados: $ACEPDIR." -l="InstalaW5.sh"
	echo 'Archivos externos rechazados: '$RECHDIR
	LOGGER_EXE -i -m="Archivos externos rechazados: $RECHDIR." -l="InstalaW5.sh"
	echo 'Archivos procesados: '$PROCDIR
	LOGGER_EXE -i -m="Archivos procesados: $PROCDIR." -l="InstalaW5.sh"
	echo 'Reportes de salida: '$REPODIR
	LOGGER_EXE -i -m="Reportes de salida: $REPODIR." -l="InstalaW5.sh"
	echo 'Logs de auditoria del Sistema: '"$LOGDIR<comando>.$LOGEXT"
	LOGGER_EXE -i -m="Logs de auditoria del sistema: $LOGDIR<comando>.$LOGEXT." -l="InstalaW5.sh"
	echo 'Estado de la instalacion: COMPLETA'
	LOGGER_EXE -a -m="Estado de la instalacion: COMPLETA." -l="InstalaW5.sh"
	echo 'Proceso de Instalación Cancelado'
	LOGGER_EXE -a -m="Proceso de instalacion cancelado." -l="InstalaW5.sh"

	return 0
}

function completarInstalacion()
{
	configFile="$directorio"'InstalaW5.conf.temp'
	generarConfiguracion
	"$directorio"InstalaW5-build.sh
	exit 0
}

function mostrarConfiguracionIncompleta()
{
	echo "Ejecutables: $BINDIR"
	LOGGER_EXE -i -m="Ejecutables: $BINDIR." -l="InstalaW5.sh"
	verificarDirectorio $BINDIR "$LISTA_BINDIR" > /dev/null
	echo "Archivos maestros: $MAEDIR"
	LOGGER_EXE -i -m="Archivos maestros: $MAEDIR." -l="InstalaW5.sh"
	verificarDirectorio $MAEDIR "$LISTA_MAEDIR" > /dev/null
	echo "Estado de la instalacion: INCOMPLETA"
	LOGGER_EXE -a -m="Estado de la instalacion: INCOMPLETA." -l="InstalaW5.sh"
	read -p "Desea completar la instalacion? (s/n)" sn
    	case $sn in
		LOGGER_EXE -i -m="Se decidio completar la instalacion." -l="InstalaW5.sh"
        	[Ss]* ) completarInstalacion;;
       		* ) exit 0;;
    	esac
	LOGGER_EXE -i -m="Se decidio no completar la instalacion." -l="InstalaW5.sh"
}

detectarInstalacion
codigo=$?
if [ $codigo -ne 100 ]; then # Se detectó instalación
	if [ $codigo -eq 0 ]; then
		mostrarConfiguracionCompleta
		exit 0
	else
		mostrarConfiguracionIncompleta
	fi
fi

#Check if Perl is installed
if perl < /dev/null > /dev/null 2>&1  ; then
      echo "Checking if Perl is installed... OK."
else
      echo "TP SO7508 Segundo Cuatrimestre 2012. Tema W Copyright © Grupo 06
Para instalar el TP es necesario contar con Perl 5 o superior instalado.
Efectúe su instalación e inténtelo nuevamente.
Proceso de Instalación Cancelado"
	LOGGER_EXE -i -m="TP SO7508 Segundo Cuatrimestre 2012. Tema W Copyright © Grupo 06." -l="InstalaW5.sh"
	LOGGER_EXE -a -m="Para instalar el TP es necesario contar con Perl 5 o superior instalado. Efectúe su instalación e inténtelo nuevamente. Proceso de Instalación Cancelado." -l="InstalaW5.sh"
	exit 1
fi

# TODO: Brindar la información de la Instalación

echo "Directorio de Trabajo para la instalacion: $GRUPO"
LOGGER_EXE -i -m="Directorio de Trabajo para la instalacion: $GRUPO" -l="InstalaW5.sh"

# TODO: Listar los archivos y subdir de GRUPO
echo "Librería del Sistema: $CONFDIR"
LOGGER_EXE -i -m="Libreria del Sistema: $CONFDIR" -l="InstalaW5.sh"
# TODO: Listar los archivos de CONFDIR

LOGGER_EXE -a -m="Estado de la instalacion: PENDIENTE" -l="InstalaW5.sh"
LOGGER_EXE -a -m="Directorio de instalacion de ejecutables a definir." -l="InstalaW5.sh"
LOGGER_EXE -a -m="Directorio de instalacion de archivos maestros a definir." -l="InstalaW5.sh"
LOGGER_EXE -a -m="Directorio de instalacion de arribo de archivos externos a definir." -l="InstalaW5.sh"
LOGGER_EXE -a -m="Directorio de instalacion de grabacion de archivos externos rechazados a definir." -l="InstalaW5.sh"
LOGGER_EXE -a -m="Directorio de instalacion de grabacion de archivos externos aprobados a definir." -l="InstalaW5.sh"
LOGGER_EXE -a -m="Directorio de instalacion de grabacion de los reportes de salida a definir." -l="InstalaW5.sh"
LOGGER_EXE -a -m="Espacio minimo libre para arribo de archivos externos a definir." -l="InstalaW5.sh"
echo "Estado de la instalacion: PENDIENTE
Para completar la instalación Ud. Deberá:
Definir el directorio de instalación de los ejecutables
Definir el directorio de instalación de los archivos maestros
Definir el directorio de arribo de archivos externos
Definir el espacio mínimo libre para el arribo de archivos externos
Definir el directorio de grabación de los archivos externos rechazados
Definir el directorio de grabacion de los archivos externos aceptados
Definir el directorio de grabación de los logs de auditoria
Definir la extensión y tamaño máximo para los archivos de log
Definir el directorio de grabación de los reportes de salida"

while true; do
	read -ep "Defina el directorio de instalación de los ejecutables:" -i "$BINDIR" BINDIR
	BINDIR=`readlink -m $BINDIR`
	read -ep "Defina el directorio de instalación de los archivos maestros:" -i "$MAEDIR" MAEDIR
	MAEDIR=`readlink -m $MAEDIR`
	read -ep "Defina el directorio de arribo de los archivos externos:" -i "$ARRIDIR" ARRIDIR
	ARRIDIR=`readlink -m $ARRIDIR`
	read -ep "Defina el espacio mínimo libre para el arribo de archivos externos en Mbytes:" -i "$DATASIZE" DATASIZE
	while ! printf "%d" $DATASIZE > /dev/null 2>&1; do
		read -ep "Defina el espacio mínimo libre para el arribo de archivos externos en Mbytes:" -i "$DATASIZE" DATASIZE
	done

	# TODO: Verificar espacio en disco

	read -ep "Defina el directorio de grabacion de los archivos externos rechazados:" -i "$RECHDIR" RECHDIR
	RECHDIR=`readlink -m $RECHDIR`
	read -ep "Defina el directorio de grabacion de los archivos externos aceptados:" -i "$ACEPDIR" ACEPDIR
	ACEPDIR=`readlink -m $ACEPDIR`
	read -ep "Defina el directorio de grabacion de los archivos externos procesados:" -i "$PROCDIR" PROCDIR
	PROCDIR=`readlink -m $PROCDIR`

	echo "Los Logs de este sistema se grabaran en: $GRUPO/log
	La extensión de los archivos de log es: .log"
	#LOGDIR="$GRUPO/log", iniciados arriba
	#LOGEXT="log", iniciados arriba


	read -ep "Defina el tamaño máximo para los archivos .$LOGEXT en Kbytes:" -i "$LOGSIZE" LOGSIZE
	while ! printf "%d" $LOGSIZE > /dev/null 2>&1; do
		read -ep "Defina el tamaño máximo para los archivos .$LOGEXT en Kbytes:" -i "$LOGSIZE" LOGSIZE
	done
	read -ep "Defina el directorio de grabacion de los reportes de salida:" -i "$REPODIR" REPODIR
	REPODIR=`readlink -m $REPODIR`

	echo "TP SO7508 1mer cuatrimestre 2012. Tema x Copyright © Grupo xx
Librería del Sistema: $CONFDIR
Ejecutables: $BINDIR
Archivos maestros: $MAEDIR
Directorio de arribo de archivos externos: $ARRIDIR
Espacio mínimo libre para arribos: $DATASIZE Mb
Archivos externos aceptados: $ACEPDIR
Archivos externos rechazados: $RECHDIR
Archivos procesados: $PROCDIR
Reportes de salida: $REPODIR
Logs de auditoria del Sistema: $LOGDIR/<comando>.$LOGEXT
Tamaño máximo para los archivos de log del sistema: $LOGSIZE Kb
Estado de la instalacion: LISTA"

    read -p "Los datos ingresados son correctos? (s/n)" sn
    case $sn in
        [Ss]* ) break;;
        * ) clear; continue;;
    esac
done

configFile="$directorio"'InstalaW5.conf.temp'
generarConfiguracion
chmod +x "${directorio}InstalaW5-build.sh"
"$directorio"InstalaW5-build.sh
exit 0

=============================================================

#/bin/bash
##########################################
# SSOO Grupo 06 - 2012, 2° Cuatrimestre  #
#         Comando Instala-build.sh       #
##########################################
# Etapa de construcción del sistema.

function agregarArchivo()
{
	local variableAmbiente="LISTA_$1"
	local archivo="$2"

	local configFile="$CONFDIR/InstalaW5.conf"
	fecha=`date +"%d/%m/%Y %H:%M"`
	chmod +w $configFile
	lista=`grep "^$variableAmbiente=" $configFile | cut -d= -f2`
	if [ "$lista" != "" ]; then
		lista=$lista' '
	fi
	sed "/^$variableAmbiente=/d" -i $configFile
	echo "$variableAmbiente=$lista$archivo=$USER=$fecha" >> $configFile
	chmod -w $configFile
}

# Copia el script $origen bajo el nombre y ruta $destino, y le da $permisos correspondientes. Además se agrega al archivo al config file como instalado en el directorio de la variable $ambiente
function instalarArchivo()
{
	local origen=$1
	local destino=$2
	local permisos=$3
	local ambiente=$4 
	if [ ! -e "$destino" ]; then
		echo "Construyendo $destino"
		cp "$origen" "$destino"
		chmod $permisos "$destino"
	else
		echo "Ignorando archivo existente: $destino"
	fi
	agregarArchivo "$ambiente" "${destino##*/}"
}

dirActual=$PWD
path=`readlink -f $0 | sed 's-/[^/]*$--'`
cd $path

# Cargamos la configuración
configFile='InstalaW5.conf'
source $configFile'.temp'

# Construcción de directorios
echo 'Creando Estructuras de directorio. . . .'
mkdir -p $GRUPO
mkdir -p $CONFDIR
mkdir -p $BINDIR
mkdir -p $MAEDIR
mkdir -p $ARRIDIR
mkdir -p $ACEPDIR
mkdir -p $RECHDIR
mkdir -p $PROCDIR
mkdir -p $REPODIR
mkdir -p $LOGDIR

# Generar archivo de configuración
echo 'Actualizando la configuración del sistema'
fecha=`date +"%d/%m/%Y %H:%M"`
if [ -e "$CONFDIR/$configFile" ]; then
	rm -f "$CONFDIR$configFile"
fi
sed 's-^.*$-&='"$USER=$fecha"'-' $configFile'.temp' > "$CONFDIR$configFile"
rm -f $configFile'.temp'
chmod 444 "$CONFDIR$configFile"
agregarArchivo CONFDIR $configFile

#cod_error file
directorioSrc="./CONFDIR"
archivo="cod_err"
instalarArchivo "$directorioSrc/$archivo" "$CONFDIR$archivo" 444 CONFDIR

echo 'Instalando Archivos Maestros'

# sistemas-MAEDIR
archivo="sistemas"
instalarArchivo "./MAEDIR/$archivo" "$MAEDIR$archivo" 444 MAEDIR

# patrones-MAEDIR
archivo="patrones"
instalarArchivo "./MAEDIR/$archivo" "$MAEDIR$archivo" 444 MAEDIR

echo 'Instalando Programas y Funciones'

# IniciarW5
directorioSrc="./BINDIR"
archivo="IniciarW5.sh"
instalarArchivo "$directorioSrc/$archivo" "$BINDIR$archivo" 544 BINDIR

archivo=".path$configFile"
if [ ! -e "$BINDIR$archivo" ]; then
	echo "$CONFDIR$configFile" > "$BINDIR$archivo"
	chmod 444 "$BINDIR$archivo"
fi
agregarArchivo BINDIR $archivo


archivo="leerConfig.sh"
instalarArchivo "$directorioSrc/$archivo" "$BINDIR$archivo" 544 BINDIR

archivo="setConfigVar.sh"
instalarArchivo "$directorioSrc/$archivo" "$BINDIR$archivo" 544 BINDIR

# Logger
archivo="Logger.pl"
instalarArchivo "$directorioSrc/$archivo" "$BINDIR$archivo" 544 BINDIR

# DetectaW5
archivo="detectaW5.sh"
instalarArchivo "$directorioSrc/$archivo" "$BINDIR$archivo" 544 BINDIR

# BuscarW5
archivo="buscarW5.sh"
instalarArchivo "$directorioSrc/$archivo" "$BINDIR$archivo" 544 BINDIR

# moverW5
archivo="moverW5.sh"
instalarArchivo "$directorioSrc/$archivo" "$BINDIR$archivo" 544 BINDIR

# startD
archivo="startD.sh"
instalarArchivo "$directorioSrc/$archivo" "$BINDIR$archivo" 544 BINDIR

# stopD
archivo="stopD.sh"
instalarArchivo "$directorioSrc/$archivo" "$BINDIR$archivo" 544 BINDIR

# ListarW5
archivo="ListarW5.pl"
instalarArchivo "$directorioSrc/$archivo" "$BINDIR$archivo" 544 BINDIR

# mirarW5
archivo="MirarW5.pl"
instalarArchivo "$directorioSrc/$archivo" "$BINDIR$archivo" 544 BINDIR

echo 'Instalacion concluida'
cd $dirActual
exit 0

=====================================================================

#!/bin/bash

##########################################
# SSOO Grupo 06 - 2012, 2° Cuatrimestre  #
#         Comando IniciarW5.sh           #
##########################################

# Este comando debe correrse sin proceso hijo, a modo de poder exportar las variables de ambiente exitosamente.
# Previamente, el comando verificara que la instalacion haya sido completa y por ultimo, enlazara el recorrido del TP iniciando el demonio.

comando_log="IniciarW5.sh"
configFile=`cat .pathInstalaW5.conf`


#Placeholder
SYSFILE=sistemas

# Muestra un listado de los archivos existentes en el directorio recibido ($1)
function mostrarDirectorio()
{
	local formato='s/^.*$/\t&/'
	ls -1 $1 | sed $formato
}

# Carga las variables de ambiente del archivo de configuración
function leerConfiguracion()
{
	if ! [ -e $configFile ]; then
		echo "El archivo de configuracion no existe"
		return 2 
	fi
	if ! [ -r $configFile ]; then
		echo "No se tienen los permisos de lectura del archivo de configuracion"
		return 3
	fi
	scriptConfig=$path'leerConfig.sh'
	if ! [ -f $scriptConfig ]; then
		echo "El comando $scriptConfig no existe"
		return 2
	fi
	if ! [ -x $scriptConfig ]; then
		echo "No se tienen los permisos para ejecutar $scriptConfig"
		return 4
	fi
	. $scriptConfig $configFile
	return 0
}

# Muestra la configuración de las variables de ambiente de este sistema
function mostrarConfiguracion()
{
	echo 'TP SO7508 Segundo Cuatrimestre 2012. Tema W Copyright © Grupo xx'
	echo 'Libreria del sistema: '$CONFDIR
	mostrarDirectorio $CONFDIR
	echo 'Ejecutables: '$BINDIR
	mostrarDirectorio $BINDIR
	echo 'Archivos maestros: '$MAEDIR
	mostrarDirectorio $MAEDIR
	echo 'Directorio de arribo de archivos externos: '$ARRIDIR
	echo 'Archivos externos aceptados: '$ACEPDIR
	echo 'Archivos externos rechazados: '$RECHDIR
	echo 'Archivos procesados: '$PROCDIR
	echo 'Reportes de salida: '$REPODIR
	echo 'Logs de auditoria del Sistema: '"$LOGDIR<comando>.$LOGEXT"
	echo 'Estado del Sistema: INICIALIZADO'
	echo 'No es posible efectuar una reinicializacion del sistema.'

	return 0
}

function verificarDirectorio()
{
	local directorio="$1"
	local lista="$2"
	local faltante=
	local cantidad=0
	for archivo in $lista; do
		if [ ! -e "$directorio$archivo" ]; then
			faltante=$faltante" $archivo"
			cantidad=`expr $cantidad + 1`
		fi
	done
	echo -e "\tComponentes existentes:"
	ls -1 $directorio | sed 's/^.*$/\t\t&/'
	echo -e "\tComponentes faltantes: $cantidad"
	for archivo in $faltante; do
		echo -e "\t\t$archivo"
	done
	return $cantidad
}

# Verifica que todos los componentes de la instalación existan
function verificarInstalacion()
{
	local faltantes=0
	echo "Ejecutables: $BINDIR"
	verificarDirectorio $BINDIR "$LISTA_BINDIR"
	faltantes=`expr $faltantes + $?`
	echo "Archivos maestros: $MAEDIR"
	verificarDirectorio $MAEDIR "$LISTA_MAEDIR"
	faltantes=`expr $faltantes + $?`
	return $faltantes
}

dirActual=$PWD
path=`readlink -f "${BASH_SOURCE[0]}"`
path=${path%'/'*}'/'
echo $path
LOGGER_EXE="perl ${path}Logger.pl"
cd $path

# Verificar si el proceso está siendo invocado como hijo
if [ ${0##*/} != 'bash' ]; then
	echo "Error: IniciarW5 no debe ser corrido como proceso hijo."
	$LOGGER_EXE -a -m="El comando Iniciar se ejecuto como proceso hijo. Imposible inicializar el sistema." -l="IniciarW5.sh"
	exit -1
fi

# Verificar si el ambiente fue inicializado previamente
if [ ! -z $ambienteInicializado ]; then
	$LOGGER_EXE -m="Comando $comando_log ya fue ejecutado." -a -l="$comando_log" > /dev/null
	mostrarConfiguracion
	echo 'Proceso de Inicializacion Cancelado'
	return 1
fi

leerConfiguracion
codigo=$?
if [ $codigo -ne 0 ]; then
	cd $dirActual
	return $codigo
fi

# Iniciar el archivo de log
$LOGGER_EXE -m="Comando $comando_log Inicio de Ejecucion" -i -l="$comando_log" > /dev/null

# Añadimos el directorio de ejecutables al path del sistema
PATH=$PATH:$BINDIR
export PATH

verificarInstalacion
codigo=$?
echo "Se termino de verificar la instalacion con codigo de salida $codigo"
if [ $codigo -ne 0 ]; then
	echo "Instalacion incompleta!"
	$LOGGER_EXE -m="La instalacion no esta completa. Reinstalar antes de volver a iniciar el ambiente." -a -l="$comando_log" > /dev/null
	return 4
fi

# El ambiente se inicio con exito
ambienteInicializado=1
export ambienteInicializado
$LOGGER_EXE -m="Se termino de iniciar el ambiente con exito." -i -l="$comando_log" > /dev/null
# exporto la funcion de mover al ambiente
source ./moverW5.sh

# Verificar si DetectaW5 está corriendo en la sesión y sino ejecutarlo en background
./startD.sh > /dev/null

cd $dirActual
return 0


=============================================================================

#!/bin/bash

##########################################
# SSOO Grupo 06 - 2012, 2° Cuatrimestre  #
#         Comando leerConfig.h           #
##########################################

# Lee el archivo de configuración $configFile y exporta todas las variables
# almacenadas en el mismo

configFile=$1
tempFile="./config.temp.sh"

if ! [ -r "$configFile" ]; then
	echo "Error: no se puede leer el archivo de configuracion"
	return 1
else
	grep "^.*=.*$" $configFile | sed 's/=[^=]*=[^=]*$//' > $tempFile
	sed -i 's/^.*$/export &"/' $tempFile
	sed -i 's/=/="/' $tempFile
	chmod 755 $tempFile
	. $tempFile
	rm -f $tempFile
	echo "Archivo de configuracion $configFile leido correctamente"
	return 0
fi

==============================================================================


#!/bin/bash

################################################
#	SSOO Grupo 06 - 2012, 2° Cuatrimestre      #
#         Comando setConfigVar.h 		           #
################################################

# Este comando auxiliar se encarga de actualizar y modificar el archivo instala.config con 
# las variables especificadas por el usuario desde el comando instala.

variable="$1"
valor="$2"

configFile="$CONFDIR/InstalaW5.conf"
fecha=`date +"%d/%m/%Y %H:%M"`
chmod +w $configFile
sed "/^$variable=/d" -i $configFile
echo "$variable=$valor=$USER=$fecha" >> $configFile
chmod -w $configFile


================================================================================

#!/bin/bash

##########################################
# SSOO Grupo 06 - 2012, 2° Cuatrimestre  #
#         Comando StartD.sh              #
##########################################

LOGGER_EXE="perl ${BINDIR}Logger.pl"
comando_log="startD.sh"

# Verifica que el demonio no se encuentre activo y lo invoca.
iniciar_demonio (){
	pid_detecta=`ps ax | grep -v $$ | grep -v grep | grep -v -w "$$" | grep detectaW5.sh`
	pid_detecta=`echo $pid_detecta | cut -f 1 -d ' '`
	if [ "${pid_detecta}1" != "1" ]; then 
		$LOGGER_EXE -m="El proceso detectaW5 ya esta corriendo. PID: ${pid_detecta}" -a -l="$comando_log"
	else
		# ejecutar detectaW5.sh
		if ! [ -a "${BINDIR}detectaW5.sh" ]; then #verifica existencia.
			$LOGGER_EXE -e -c="124"	# archivo inexistente.
		else
			if ! [ -x "${BINDIR}detectaW5.sh" ]; then # verifica permisos.
				$LOGGER_EXE -e -c="404"	# falta de permisos de ejecucion.
			else
				${BINDIR}detectaW5.sh & # ejecuta el daemon en paralelo.
				pid_detecta=$(pidof -x detectaW5.sh)
				$LOGGER_EXE -m="El proceso detectaW5 se inicio correctamente, PID: ${pid_detecta}" -i -l="$comando_log"
			fi
		fi
	fi
}

# verifico que el ambiente haya sido iniciado.
if [ -z "$ambienteInicializado" ]; then # El ambiente no esta inicializado.
	$LOGGER_EXE -e -c="801" -l="$comando_log"
elif [ ! -d "$BINDIR" -o ! -d "$ARRIDIR" -o ! -d "$RECHDIR" -o ! -d "$ACEPDIR" ]; then
	$LOGGER_EXE -e -c="802" -l="$comando_log" # directorio invalido.
else	# inicio demonio
	iniciar_demonio
fi


======================================================================================


#!/bin/bash

##########################################
# SSOO Grupo 06 - 2012, 2° Cuatrimestre  #
#         Comando StopD.sh               #
##########################################


LOGGER_EXE="perl ${BINDIR}Logger.pl"

# Verifica que haya un demonio activo en la sesion, y lo termina.

pid=$(pidof -x "${BINDIR}detectaW5.sh")
if [ "${pid}1" = "1" ]; then # deamon no se esta ejecutando
	$LOGGER_EXE -m="El demonio no esta corriendo. Imposible parar proceso." -a -l="stopD.sh"
else
	kill $pid # termina proceso deamon
	$LOGGER_EXE -m="El demonio se termino exitosamente." -i -l="stopD.sh"
fi


=======================================================================================


#!/bin/bash

##########################################
# SSOO Grupo 06 - 2012, 2° Cuatrimestre  #
#         Comando detectaW5.sh           #
##########################################

# Este comando no utiliza opciones o argumentos. Sin embargo los comandos que lo invocan, lo ejecutan en 
# segundo plano de la siguiente forma: ./detectaW5.sh &

sleep_time=20 # intervalo de tiempo de suspension del daemon

SYSFILE=sistemas
LOGGER_EXE="perl ${BINDIR}Logger.pl"

cod_se=666
comando_log="detectaW5.sh"

iniciar_buscarW5 (){
	pid_buscar=$(pidof -x buscarW5.sh)
	if [ "${pid_buscar}1" != "1" ]; then # Proceso existe => Alerta => Termina
		$LOGGER_EXE -m="El proceso buscarW5 ya esta corriendo.PID: ${pid_buscar}" -a -l="$comando_log"
	else
		# Ejecuta buscarW5.sh
		if [ ! -f "${BINDIR}buscarW5.sh" ]; then # Verifica existencia
			$LOGGER_EXE -e -c="124"	# Archivo inexistente
		else
			if [ ! -x "${BINDIR}buscarW5.sh" ]; then # Verifica permisos de ejecucion
				$LOGGER_EXE -e -c="710"
			else
				${BINDIR}buscarW5.sh & # Ejecuta en paralelo
			fi
		fi
	fi
}

# Comienzo del demonio.
$LOGGER_EXE -m="Inicio de ejecucion de comando DetectaW5." -i -l=${comando_log}
i=0
while :
do
	if [ $i != 0 ]
	then
		sleep $sleep_time # La primer iteracion se saltea.
	else
		i=1
	fi

	# Verifica si ARRIDIR essta vacio
	if [ $(ls $ARRIDIR | wc -l) == "0" ]
	then
		echo "no files in ARRIDIR"
		$LOGGER_EXE -m="No se encontraron archivos en ARRIDIR." -i -l=${comando_log}
	fi

	for FILE in `find $ARRIDIR -type f -exec basename "{}" \; | grep ^[a-Z][^_]*_[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]$`; do
		# Muevo todos los archivos que contemplan el formato de nombre: string_nnnn-nn-nn

		# Get fecha del archivo
		fileDate=$(basename $FILE | cut -d "_" -f2)	#YYYY-mm-dd
		if [[  $fileDate != [0-9][0-9][0-9][0-9]-[0-1][0-9]-[0-3][0-9] ]];
		then
			moverW5 "${ARRIDIR}${FILE}" "$RECHDIR" detectaW5.sh
			$LOGGER_EXE -m="Archivo \"$FILE\" rechazado. Fecha invalida." -a -l=${comando_log}
			continue
		fi

		filedateSec=$(date -d $fileDate +%s) #paso a segundos a partir de 1970-01-01
		
		# Fecha actual
		Now_tmp=$(date +%F)
		NowSec=$(date -d $Now_tmp +%s)
		
		if [ $filedateSec -gt $NowSec ]; # FileDate > NOW : Fecha futura.
		then
			moverW5 "${ARRIDIR}${FILE}" "$RECHDIR" detectaW5.sh
			$LOGGER_EXE -m="Archivo \"$FILE\" rechazado. Fecha posterior a fecha actual." -a -l=${comando_log}
			continue
		fi

		# Verifico el codigo del archivo con archivo MAESTRO
		# File ID
		fileId=$(basename $FILE | cut -d "_" -f1)
		# Veo si existe en el archivo maestro
		if [ $(grep -c ^$fileId,[^,][^,]*,[^,][^,]*,[^,]*$ ${MAEDIR}$SYSFILE) == 0 ]
		then
			moverW5 "${ARRIDIR}${FILE}" "$RECHDIR" detectaW5.sh
			$LOGGER_EXE -m="Archivo \"$FILE\" rechazado. Sistema inexistente." -a -l=${comando_log}	
			continue
		fi

		# Ver que el archivo maestro se recorre hasta la primera aparición del id (luego break)
		# Match SIS_ID,?*,?*,* || (sis_baja puede ser nula)
		while read -r SIS; do
			[[ $(echo $SIS | cut -f1 -d ",") != "$fileId" ]] && continue
			tmp_sis_alta=$(echo $SIS | cut -f3 -d ",") 
			sis_alta=$(date -d $tmp_sis_alta +%s)
			tmp_sis_baja=$(echo $SIS | cut -f4 -d ",")
			sis_baja=""
			if [ "$tmp_sis_baja" != "" ]; then
				sis_baja=$(date -d $tmp_sis_baja +%s)
			fi
			break
		done <${MAEDIR}$SYSFILE
		
		# FileDate < SIS_ALTA
		if [ $filedateSec -lt $sis_alta ]; then
			moverW5 "${ARRIDIR}$FILE" "$RECHDIR" detectaW5.sh
			$LOGGER_EXE -m="Archivo \"$FILE\" rechazado. Fecha anterior a fecha de alta." -a -l=${comando_log}	
			continue
		fi

		# FileDate > SIS_BAJA
		if [ "${filedateSec}1" -gt "${sis_baja}1" ]
		then
			moverW5 "${ARRIDIR}$FILE" "$RECHDIR" detectaW5.sh
			$LOGGER_EXE -m="Archivo \"$FILE\" rechazado. Fecha posterior a fecha baja del sistema." -a -l=${comando_log}	
			continue
		else # no hubo errores. Archivo valido!
			moverW5 "${ARRIDIR}$FILE" "$ACEPDIR" detectaW5.sh
			$LOGGER_EXE -m="Archivo \"$FILE\" aceptado." -i -l=${comando_log}
			continue
		fi
	done

	for FILE in `find $ARRIDIR` # recorre los arhivos que no contemplaban el formato
	do
		[[ -d $FILE ]] && continue
		moverW5 "$FILE" "$RECHDIR" detectaW5.sh
		if [ -f $FILE ]; then
			$LOGGER_EXE -m="Archivo \"$FILE\" rechazado. Formato de nombre invalido."  -a -l=${comando_log}
		else
			$LOGGER_EXE -m="Archivo \"$FILE\" rechazado. Formato de archivo invalido. No es un archivo regular."  -a -l=${comando_log}
		fi
	done

	# Verifico que ACEPDIR tenga archivos
	if [ $(ls $ACEPDIR | wc -l) -gt 0 ]; then
		$LOGGER_EXE -m="El directorio de archivos aceptados \"$ACEPDIR\" no esta vacio. Se ejecuta el comando \"buscarW5\".." -i -l="$comando_log"
		# Invoco BuscarW5
		iniciar_buscarW5
	fi
done


==================================================================================


#!/bin/bash

#########################################
#	Grupo 06 - 2012 2° Cuatrimestre	    #
#		Comando buscarW5.sh 		    #
#########################################

CONFIG="${CONFDIR}InstalaW5.conf"
LOGGER_EXE="perl ${BINDIR}Logger.pl"

ARCHPATRONES="${MAEDIR}patrones"
ARCHSISTEMAS="${MAEDIR}sistemas"
ARCHLOG="${LOGDIR}BuscarW5.log"
CICLOS=1

TMP="temp"
TMP_PATRONES="temp_patrones"
TMP_HALLA="temp_halla"
FOUND="found"


# Carga la variable CICLOS desde el archivo de configuracion
function cargarCiclos() {
	CICLOS=$(grep SECUENCIA2 $CONFIG | cut -f2 -d'=')
}


# Recibe una variable de tipo string la convierte a int
function atoi() {
	local i
	i=$(echo "$1" | tr -d $'\r')
	return $(echo $i | bc)
}


# Busca la cantidad de archivos a procesar
# Es igual a la cantidad de archivos en ACEPDIR
function getCantArch() {
	atoi $(ls $ACEPDIR | wc -w)
	return $?
}


#DEPRECATED
# Actualiza los ciclos en el archivo de configuracion
function actualizaCiclos() {
	sed -i s/SECUENCIA2=[0-9][0-9]*/SECUENCIA2="$CICLOS"/ $CONFIG
}


# Graba el inicio del proceso en el archivo de log
# Recibe el numero de ciclo y la cantidad de archivos a procesar
function grabarInicio(){
	echo "Inicio BuscarW5 – Ciclo Nro.: $1 - Cantidad de Archivos: $2" >> $ARCHLOG
}


# Recibe el nombre del archivo y devuelve el SIS_ID
function getSisId() {
	echo $(echo $1 | cut -f1 -d'_')
}


# Dado un SisId, devuelve el nombre del sistema
# Actualmente esta función NO se usa, pero la dejo hecha (por las dudas, vió?)
function getNombreSistema() {
	local res=$(grep "$1" $ARCHSISTEMAS)
	echo $(echo $res | cut -f2 -d',')
}


# Recibe PATH/fileName y devuelve fileName
function getNombreArchivo() {
	cant=$(grep -o "/" <<< $1 | wc -l)
	cant=$(( $cant + 1 ))
	echo $(echo $1 | cut -f$cant -d'/')
}


function procesarArchivo() {
	
	local NAME=$(getNombreArchivo $1)
	local PATHARCHIVO=$1
	local HayHalla=0
	
	# Escribe el log con el archivo a procesar
	echo "Archivo a procesar: $NAME" >> $ARCHLOG
	 
	# Obtengo el SIS_ID a partir del nombre del archivo
	local SIS_ID=$(getSisId $NAME)
	# Obtiene el nombre del sistema (en caso que sea necesario)
	#local SISTEMA=$(getNombreSistema $SIS_ID)
	
	# Guarda todas las lineas de patrones que corresponde buscar para
	# este archivo
	grep $SIS_ID $ARCHPATRONES >> $TMP_PATRONES
	
	if [ ! -s $TMP_PATRONES ] ; then # Veo que el archivo no esté vacío
		echo "No hay patrones aplicables para este archivo" >> $ARCHLOG
		SinPatron=$(( $SinPatron + 1 ))
		HayHalla=-1		#flag
	fi
	
	while IFS=, read PAT_ID PATRON SIS_ID CTX DESDE HASTA
	do
		echo "$PAT_ID,$PATRON,$SIS_ID,$CTX,$DESDE,$HASTA"
		
		# Valido que no este repetido
		if [ -e "${PROCDIR}${NAME}" ]; then
			moverW5 ${PROCDIR}${NAME} $RECHDIR # el ARCHIVO a RECHDIR empleando la función MoverW5
			$LOGGER_EXE -e -c=303 -l="BuscarW5.sh"
			continue
		fi
		
		local ArchResGlobal="rglobales.$PAT_ID"
		local ArchResultado="resultados.$PAT_ID"
		
		atoi $DESDE
		DESDE=$?
		atoi $HASTA
		HASTA=$?
		
		if [ "$DESDE" -gt "$HASTA" ] ; then
			$LOGGER_EXE -e -c=236 -l="BuscarW5" # archivo patrones invalido
			continue
		fi
		
		# Saco las comillas del patron
		local RegExp=$(echo $PATRON | sed "s/'//g")
		
		
		# Paso todos los hallazgos a un archivo temporal
		grep "$RegExp" $PATHARCHIVO >> $TMP_HALLA
		
		HALLAZGOS=0
		
		while read MATCH # Voy leyendo los hallazgos
		do
			HayHalla=1 # flag
			HALLAZGOS=$(( $HALLAZGOS + 1 ))
			
			if [ "$CTX" = "linea" ] ; then
				
				# Me quedo desde el match hasta "HASTA" inclusive
				local res=$(fgrep -A $HASTA "$MATCH" $PATHARCHIVO | sed -n "$DESDE","$HASTA"p)
				
				echo "$CICLOS+-#-+$NAME+-#-+$HALLAZGOS+-#-+$res" >> $ArchResultado
			fi
			
			if [ "$CTX" = "caracter" ]; then
				local res=$(fgrep "$MATCH" $PATHARCHIVO | uniq)
				# me quedo con la parte de la linea que me interesa
				local resCut=$(cut "-c$DESDE-$HASTA" <<< "$res")

				echo "$CICLOS+-#-+$NAME+-#-+$HALLAZGOS+-#-+$resCut" >> $ArchResultado
			fi
		
		done < $TMP_HALLA
		
		# FIN PATRON
		echo "$CICLOS,$NAME,$HALLAZGOS,$PATRON,$CTX,$DESDE,\
$HASTA" >> $ArchResGlobal
		
		rm -f $TMP_HALLA
	
	done < $TMP_PATRONES
	
	rm -f $TMP_PATRONES
	
	if [ $HayHalla -eq 0 ]; then
		SinHalla=$(( $SinHalla + 1 ))
	elif [ $HayHalla -gt 0 ]; then
		ConHalla=$(( $ConHalla + 1 ))
	fi
}


buscarW5() {
	
	# Verifico que no haya otro BuscarW5 corriendo
	local res=$(ps | grep -c BuscarW5.sh)
	atoi $res
	res=$?
	if [ $res -gt 2 ]; then
		$LOGGER_EXE -e -c="920" -l="BuscarW5.sh"
		return
	fi
		
	SinPatron=0
	ConHalla=0
	SinHalla=0
	
	cargarCiclos
	getCantArch
	grabarInicio $CICLOS $?
	for FILE in `ls $ACEPDIR`
	do
		procesarArchivo ${ACEPDIR}$FILE
		moverW5 ${ACEPDIR}$FILE $PROCDIR "buscarW5.sh"
		
	done
	$LOGGER_EXE -m="Fin del Ciclo: $CICLOS - Cantidad de Archivos con Hallazgos: $ConHalla – Cantidad de Archivos sin Hallazgos: $SinHalla – Cantidad de Archivos sin Patrón aplicable: $SinPatron" -i -l="BuscarW5.sh"
	
	let CICLOS=$CICLOS+1
	setConfigVar.sh SECUENCIA2 $CICLOS
}

buscarW5

=================================================================================


#!/bin/bash
# move function

##########################################
# SSOO Grupo 06 - 2012, 2° Cuatrimestre  #
#         Funcion moverW5.sh             #
##########################################

# Uso de la funcion: ./moverW5 <path/archivo_fuente> <path_destino> <comando_ejecutor>*
# * El ultimo comando es opcional, el cual especifica desde donde fue llamada la funcion mover.
# La funcion de este script es la de mover, no copiar, el archivo fuente especificado al directorio destino, luego de #  realizar las validaciones de los datos de entrada.

LOGGER_EXE="perl $BINDIR/Logger.pl"
comando_log="moverW5.sh"

moverW5()
{
local comando_log="moverW5.sh"

if [ $# -gt 3 ]; then
	$LOGGER_EXE -m="Demasiados argumentos. Usage: moverW5 <sourceFile> <destFolder> [commandInvoked]" -a -l="$comando_log"
	return 1
fi

if [ $# -lt 2 ]; then
	$LOGGER_EXE -m="pocos argumentos. Usage: moverW5 <sourceFile> <destFolder> [commandInvoked]" -a -l="$comando_log"
	return 1
fi

if [ ! -d "$2" ]; then
	$LOGGER_EXE -e -c="802" -l="$comando_log" # directorio destino invalido
	return 1
fi

commandUsed=""
source_filename="${1##*/}"
source_directory="${1%/*}"
dest_path="$2"
if [ ! -d "$source_directory" ]; then
	$LOGGER_EXE -e -c="802" -l="$comando_log" # directorio fuente invalido.
	return 1
fi

if [ $(echo $2 | grep '.*/$' | wc -l) -eq 0 ]; then
	dest_path=${2}/  # agrego barra al directorio destino porque no tenia.
fi

if [ $# -eq 3 ]; then
	commandUsed=$3
fi

if [ -f "$1" ]; then # archivo fuente existe.
  	if [ -f "${dest_path}${source_filename}.0" ]; then # archivo fuente ya se encuentra en el directorio destino
		sequence_number=$(ls $dest_path -1 | grep "^$source_filename.[0-9][0-9]*" | wc -l)
		mv $1 "${dest_path}${source_filename}.$sequence_number" # muevo agregando la secuencia como extension.
	else
		mv $1 "${dest_path}${source_filename}.0"
	fi
	if [ "$commandUsed" -eq "" ]; then
		$LOGGER_EXE -m="Funcion mover exitosa." -i -l="$comando_log"
	else
		$LOGGER_EXE -m="Funcion mover exitosa en ambiente $commandUsed." -i -l="$comando_log"
	fi
else
	$LOGGER_EXE -e -c="124" -l="$comando_log" #archivo fuente invalido
	return 1
fi
return 0
}

export -f moverW5


===================================================================================


#!usr/bin/perl -w

############################################
#	Grupo 06 - 2012 2° Cuatrimestre		   #
#    	   Comando MirarW5.pl 			   #
############################################

# se invoca: MirarW5.pl -c=[comando] -n=[cant lineas]* -s=[cadena]*
# * puede ser uno, el otro, o ambos
# [comando] es el nombre del comando que se desea visualizar el archivo
# de log. 

$LOGDIR = $ENV{LOGDIR};
$LOGEXT = $ENV{LOGEXT};

# Recibe cadena y una referencia donde guardo lo que esta
# despues del igua
sub parsear($\$){
    @values = split('=', $_[0]);
    ${$_[1]} = $values[1];	
}


# Recibe el nombre de un archivo y una cadena.
# Muestra por pantalla las apariciones de la cadena en el archivo
sub muestraPorCadena($$) {
	return `grep $_[1] $_[0]`;
}

# Recibe el nombre de un archivo y una cantidad n de líneas.
# Muestra por pantalla las últimas n líneas del archivo
sub muestraPorLinea($$) {
	return `tail -n $_[1] $_[0]`;
}

# Recibe el nombre de un archivo, una cadena y una cantidad n de líneas
# Muestras las últimas n líneas con la cadena
sub combinado($$$) {
	return `grep $_[1] $_[0] | tail -n $_[2]`;
}


sub imprimeResultados(@) {
	foreach (@_) {
		@cad = split('-', $_);
		print "FECHA:$cad[0], USER:$cad[1], MOTIVO:$cad[3], MENSAJE: $cad[4]"
	}
}


sub main() {
	local($comando,$cantLineas, $cadena, $n, $s, $archivo); 
	$n = $s = 0;
	$comando = "";
	@vec = ();
	foreach (@ARGV) {
		if ($_ =~ /-c=/) {
			parsear($_,$comando);
		} elsif ($_ =~ /-s=/) {
			parsear($_,$cadena);
			$s = 1;
		} elsif ($_ =~ /-n=/) {
			parsear($_,$cantLineas);
			$n = 1;
		}
	}
	if ( ! $comando){
		print "ERROR: No se especifico el comando del log a ser evaluado. Usar la opcion -c=.. para su evaluacion.\n";
		return;
	}
	$archivo = $LOGDIR . $comando . $LOGEXT;
	if ( ! -e $archivo) {
		print "ERROR: No existe archivo de log relacionado al comando $comando\n";
		return;
	}

	$cantLineas = abs($cantLineas);
	if ($n && $s) {
		@vec = combinado($archivo, $cadena, $cantLineas); 
	} elsif ( $s ) {
		@vec = muestraPorCadena($archivo, $cadena);
	} elsif ( $n ) {
		@vec = muestraPorLinea($archivo, $cantLineas);
	} else {
		print "No se especifico ningun tipo de filtro. Usar las opciones -n=.. (cantidad de lineas) y/o -s=.. (patron de caracteres).\n";
		return;
	}
	imprimeResultados(@vec);
	
	$n_lineas = @vec;
	if ($s && $n_lineas == 0) {
		print "No hay coincidencias de la cadena $cadena en el archivo $archivo\n";
	} elsif ($n && $n_lineas < $cantLineas) {
		print "No hay más líneas que mostrar. El archivo contiene $n_lineas líneas\n"
	}
}

main();


==============================================================================================

#!usr/bin/perl -w

##########################################
# SSOO Grupo 06 - 2012, 2° Cuatrimestre  #
#         Comando Logger.pl              #
##########################################

# Forma de uso del script
# Invocacion: $ perl Logger.pl -c=[codigo] -l=[script] [TAG] [OPCIONAL -m=[mensaje]]

# -c=[codigo] : valor numérico que identifica al error. Debe estar 
# registrado en el archivo 'cod_err'

#-l=[script] : nombre del script que invoca al logger

#[TAG] : Puede ser -i, -a, -e, -s.
# -i : Información 
# -a : Alerta
# -e : Error
# -s : Error Severo

#-m=[mensaje] : mensaje clarificador del logueo 
# En casos de Error y Error Severo NO se lo utiliza


$CONFDIR= $ENV{CONFDIR};
$logdir = $ENV{LOGDIR};
$logsize = $ENV{LOGSIZE};  		# 1024000; ver que en la var de ambiente este en bytes
$logext = $ENV{LOGEXT} 			# ".log";  Ver que en la var de ambiente este el "." agregado o  agregarlo acá
$logext = "." . $logext;		# Agrega el punto (.) a la extensión
$archCodErr = "${CONFDIR}cod_err";

$tag = "Default";
$mensaje = "Default";
$lugar = "Default";
$codigo = "Default";
$error="Default";

sub getValorGrep($$){
	# Recibe el nombre del archivo y la clave a buscar con grep
	# Parsea lineas de la forma 'clave=valor'. Devuelve 'valor'
	local @res=split("=",`grep ^$_[1] $_[0]`);
	chomp($res[1]);
	return $res[1];
}

sub timeStamp(){
    # Devuelve una cadena de la forma "dia/mes/año-hora"    
    @mom = localtime();
    local $s = ($mom[5] + 1900) . ($mom[4] + 1);
    if (length($mom[3]) == 1) {
		$s .= "0";
	}
    $s .= $mom[3] . " " . $mom[2] . ":" . $mom[1] . ":" . $mom[0];
    return $s;
}


sub parsear($\$){
# Recibe cadena y una referencia donde guardo lo que esta
# despues del igual
    @values = split('=', $_[0]);
    ${$_[1]} = $values[1];
	
}


sub escribir($$){
	local($s,$f,$ARCH);	
	$f = $_[0]; $s = $_[1];	#$f nombre del archivo, $s msj a escribir
	$f .= $logext;
	#`chmod 0666 $f`;		# Habilita permisos de r y w para todos (y todas)
    open($ARCH, ">>", "${logdir}$f") or die "No puede abrir archivo '$logdir$f': [$!]\n";
    print $ARCH $s;
	close ($ARCH);
}


sub validar(\$){ 
    #valida que el mensaje sea ASCII
    ${$_[0]} =~ s/[^\x00-\x7F]//g;
}


sub mantieneTam($){
	# Recibe $lugar. Si esta excedido de tamanio, lo achica
	local $orig = "${logdir}$_[0]";
	$orig .= $logext;
	local @res = split(" ",`wc -c $orig`);	# obtiene el tam del original
	local $tam = $res[0];
	if ($tam > $logsize) {
		@res = split(" ",`wc -l $orig`); # obtiene la cant de lineas del orig
		local $len = $res[0];
		local $mitad = int($len / 2);	
		`sed '1,$mitad d' <$orig >aux`;	# Borra la mitad de las lineas 
							# del orig y manda las que quedan a aux
		`rm -f $orig`;
		`mv aux $orig`;	
	}
}


sub getArgumentos() {
	foreach (@ARGV) {
		if ($_ =~ /-l=/){
			parsear($_,$lugar);
		}

		elsif ($_ =~ /-c=/){
			parsear($_,$codigo);
		}

		elsif ($_ =~ /-m=/){
			parsear($_,$mensaje);
		}

		elsif ($_ eq "-i"){
			$tag = "INFO";
		}

		elsif ($_ eq "-a"){
			$tag = "ALERTA";
		}

		elsif ($_ eq "-e"){
			$tag = "ERROR";
		}

		elsif ($_ eq "-s"){
			$tag = "ERROR_SEVERO";
		}
	}
}


sub main() {

	getArgumentos();
	validar($mensaje);
    local $tiempo = timeStamp();

	if ($tag eq "ERROR" || $tag eq "ERROR_SEVERO"){
		$error = getValorGrep($archCodErr, $codigo);
	} else {
		$error = $mensaje;
	}

	local $user = `whoami`;	# obtiene el usuario del script
	chomp($user);
	
	$cad = "$tiempo-$user-$lugar-$tag-$error\n";
	print $cad;

	escribir($lugar,$cad);
	mantieneTam($lugar);
}


main();


================================================================================

#!/usr/bin/perl -w

########################################################
# 	    SSOO Grupo 06 - 2012, 2° Cuatrimestre		   #
# 			Comando ListarW5.pl                        #
########################################################

# Descripción:
#	Parte del sistema W-FIVE. Resuelve consultas efectuadas
#	sobre los archivos de resultados globales y de resultados
#	detallados, mostrando la salida por stdout.
#
#	Argumentos:
#	-r
#		la consulta lista resultados extraídos de los archivos
#		de resulados detallados (resultados.PAT_ID).
#	-g
#		la consulta lista resultados extraídos de los archivos
#		de resultados globales (rglobales.PAT_ID).
#	-x
#		además de imprimir la salida por stdout graba el 
#		resultado en REPODIR/salida_xxx, con xxx un descriptor
#		que identifica unívocamente a cada ejecución del 
#		programa.
#	-h
#		muestra la ayuda.
#	
#	Los parámetros -g y -r son mutuamente excluyentes.
#
# Salida:
#	0	en caso de éxito;
#	-1 	en caso de error.
#

# Levanto las variables de ambiente.
$CONFDIR = $ENV{CONFDIR};
$BINDIR = $ENV{BINDIR};
$MAEDIR = $ENV{MAEDIR};
$PROCDIR = $ENV{PROCDIR};
$REPODIR = $ENV{REPODIR};
$ARCHCONF = $CONFDIR . "InstalaW5.conf";
$ARCHPAT = $MAEDIR . "patrones";
$ARCHSIS = $MAEDIR . "sistemas";
$LOGGER_EXE = "perl $BINDIR"."Logger.pl ";
local $comando_log = "ListarW5.pl";


# *************************************************************
# 	Funciones auxiliares relacionadas a la carga de filtros 
#	disponibles en el sistema.
# *************************************************************

# Crea un hash con la información de los sistemas por ID.
# CREA: %sistemas.
sub obtenerSistemasValidos(){
	# Verifica la existencia del archivo de patrones.
	if(-e $ARCHSIS){
		open(SISTEMAS, "< $ARCHSIS") or die 
			"No se pudo abrir archivo de sistemas.\n";
	}
	else{
		`$LOGGER_EXE -e -c=124 -l=$comando_log`;
	}

	# Agrega los pares ID / nombre al hash sistemas.	
	while(my $linea = <SISTEMAS>){
		$linea =~ /^(.*),(.*),.*,.*$/;
		$sistemas{$1} = $2;
	}
	close(PATRONES);
}


# Crea un hash con la información de los patrones por ID.
# CREA: %patrones.
sub obtenerPatronesValidos(){
	# Verifica la existencia del archivo de patrones.
	if(-e $ARCHPAT){
		open(PATRONES, "< $ARCHPAT") or die 
			"No se pudo abrir archivo de patrones.\n";
	}
	else{
		`$LOGGER_EXE -e -c=124 -l=$comando_log`;
	}

	# Agrega los pares ID / patrón al hash patrones.	
	while(my $linea = <PATRONES>){
		$linea =~ /^(.*),'(.*)',.*,.*,.*,.*$/;
		$patrones{$1} = $2;
	}
	close(PATRONES);
}


# Crea un hash con los nombres de todos los archivos procesados.
# CREA: %archivos.
sub obtenerArchivosValidos(){
	opendir(PROCDIR, $PROCDIR) or die
		"No se pudo abrir directorio de archivos procesados.\n";
	
	# Leo archivos del directorio de procesados...
	my @archivo = readdir(PROCDIR);
	foreach (@archivo){ 
		# ...ignorando archivos que son de resultados.
		if($_ !~ /.*\..*/){
			$archivos{$_} = "";
		}
	}
	close(PROCDIR);
}


# Busca en ARCHCONF el registro SECUENCIA2, que es la que indica
# el número de último ciclo.
# CREA $ultimoCiclo.
sub obtenerUltimoCiclo(){
	# Verifica la existencia del archivo de configuración.
	if(-e $ARCHCONF){
		my $archconfig = $CONFDIR . "buscar.config";	# TODO borrar después
		open(CONFIG, "< $archconfig") or die			# TODO borrar después
#		open(CONFIG, "< $ARCHCONF") or die
			"No se pudo abrir archivo de configuraciones.\n";
	}
	else {
		`$LOGGER_EXE -e -c=124 -l=$comando_log`; 
	}

	# Busca el registro SECUENCIA2 que almacena el último ciclo. 
	while(my $linea = <CONFIG>){
		if($linea =~ /^CICLOS=(.+)$/){
#		if($linea =~ /^SECUENCIA2=(.+)$/){
			$ultimoCiclo = $1 - 1;
		}
	}
	close(CONFIG);
}


# *************************************************************
# 	Funciones auxiliares relacionadas a la impresión por 
#	pantalla de filtros.
# *************************************************************

# Imprime por pantalla la lista de patrones disponibles.
# USA: %patrones.
sub imprimirPatronesDisponibles{
	print("Patrones disponibles: \n");
	for my $id (sort {$a <=> $b} keys %patrones){
		print("\t ID: $id - Patrón: $patrones{$id} \n");
	}
	if(scalar(keys(%patrones)) == 0){
		print("\t Ninguno. \n");
	}
}


# Imprime por pantalla la lista de archivos disponibles.
# USA: %archivos.
sub imprimirArchivosDisponibles{
	print("Archivos disponibles: \n");	
	for my $archivo (sort {$a cmp $b} keys %archivos){
		print("\t $archivo \n");
	}
	if(scalar(keys(%archivos)) == 0){
		print("\t Ninguno. \n");
	}
}


# Imprime por pantalla la lista de sistemas disponibles.
# USA: %sistemas.
sub imprimirSistemasDisponibles{
	print("Sistemas disponibles: \n");
	for my $id (sort {$a cmp $b} keys %sistemas){
		print("\t ID: $id - Patrón: $sistemas{$id} \n");
	}
	if(scalar(keys(%sistemas)) == 0){
		print("\t Ninguno. \n");
	}
}


# Imprime por pantalla la lista de patrones para filtrar.
# USA: %patrones, %f_patrones.
sub imprimirPatronesFiltrados{
	imprimirInforme("Patrones filtrados: \n");
	if(scalar(keys(%f_patrones)) == 0){
		imprimirInforme("\t Ninguno. \n");
	}	
	elsif(scalar(keys(%patrones)) == scalar(keys(%f_patrones))){
		imprimirInforme("\t Todos. \n");
	}
	else{
		for my $id (sort {$a <=> $b} keys %f_patrones){
			imprimirInforme("\t ID: $id - Patrón: $patrones{$id} \n");
		}
	}
}


# Imprime por pantalla la lista de archivos para filtrar.
# USA: %archivos, %f_archivos.
sub imprimirArchivosFiltrados{
	imprimirInforme("Archivos filtrados: \n");
	if(scalar(keys(%f_archivos)) == 0){
		imprimirInforme("\t Ninguno. \n");
	}
	elsif(scalar(keys(%archivos)) == scalar(keys(%f_archivos))){
		imprimirInforme("\t Todos. \n");
	}
	else{
		for my $id (sort {$a cmp $b} keys %f_archivos){
			imprimirInforme("\t $id \n");
		}
	}
}


# Imprime por pantalla la lista de ciclos para filtrar.
# USA: $ultimoCiclo, %f_ciclos.
sub imprimirCiclosFiltrados{
	imprimirInforme("Ciclos filtrados: \n");
	if(scalar(keys(%f_ciclos)) == 0){
		imprimirInforme("\t Ninguno. \n");
	}	
	elsif(scalar(keys(%f_ciclos)) == $ultimoCiclo){
		imprimirInforme("\t Todos. \n");
	}
	else{
		for my $ciclo (sort {$a <=> $b} keys %f_ciclos){
			imprimirInforme("\t Ciclo $ciclo \n");
		}
	}
}


# Imprime por pantalla la lista de sistemas para filtrar.
# USA: %sistemas, %f_sistemas.
sub imprimirSistemasFiltrados{
	imprimirInforme("Sistemas filtrados: \n");
	if(scalar(keys(%f_sistemas)) == 0){
		imprimirInforme("\t Ninguno. \n");
	}
	elsif(scalar(keys(%sistemas)) == scalar(keys(%f_sistemas))){
		imprimirInforme("\t Todos. \n");
	}
	else{
		for my $id (sort {$a cmp $b} keys %f_sistemas){
			imprimirInforme("\t ID: $id - Patrón: $sistemas{$id} \n");
		}
	}
}


# *************************************************************
# 	Funciones auxiliares relacionadas al ingreso de filtros.
# *************************************************************

# Función que espera el ingreso numérico del usuario y muestra un mensaje
# de error si el ingreso no es numérico.
sub ingresoNumerico(){
	$selValida = 0;
	while(!$selValida){
		chomp($numero = <STDIN>);
		if($numero =~ /^[0-9]+$/){
			$selValida = 1;
		}
		else{
			print("Selección inválida. Ingrese nuevamente. \n");
		}
	}
	return $numero;
}


# Guía al usuario en el ingreso de patrones para filtrar los resultados. 
# Almacena en el hash %f_patrones los patrones seleccionados para filtrar.
# USA: $rModo, $g, %patrones.
# CREA / ACTUALIZA: %f_patrones.
sub obtenerFiltrosDePatron(){
	imprimirPatronesDisponibles();
	# Si el modo de filtado es por patrón, sólo se permite elegir uno.
	# (sólo modo -r)
	if($rModo eq "p"){
		print("Ingrese un ID de patrón: \n");
	# Sino se pueden elegir varios.
	} 
	else{
		print("Ingrese ID de patrones para filtrar;\n");
		print("ingrese * para agregar todos los patrones al filtro; \n");
		print("ingrese entrar para terminar. \n");
	}

	my $finDeIngreso = 0;
	local $agregados = 0;
	while(!$finDeIngreso){
		chomp(my $patron = <STDIN>);
		# Sólo se permite salir con entrar cuando:
		#	- el modo es -g.
		# 	- el modo es -r y se agregaron patrones.
		if(($patron eq "") && ($g || $agregados)){
			$finDeIngreso = 1;
		}
		# Se permite agregar a todos los patrones cuando el modo no es "p".
		elsif(($patron eq "*") && ($rModo ne "p")){
			foreach(keys(%patrones)){
				$f_patrones{$_} = 0;
			}
			$agregados = 1;
		}
		# Si el patrón ya está en el filtro se lo elimina.
		elsif(exists $f_patrones{$patron}){
			delete($f_patrones{$patron});
			print("Se ha eliminado el patrón seleccionado. \n");
			if(scalar(keys(%f_patrones)) == 0){
				$agregados = 0;
			}
		}
		# Si el patrón existe y no está en el filtro se lo agrega.
		elsif(exists $patrones{$patron}){
			$f_patrones{$patron} = 0;
			# El modo -r "p" sólo permite seleccionar un patrón.
			if($rModo eq "p"){
				$finDeIngreso = 1;
			}
			$agregados = 1;
		}
		else{
			print("Patrón especificado inválido. Seleccione nuevamente.\n");
		}
	}
}


# Guía al usuario en el ingreso de nombres de archivo para filtrar los resultados. 
# Almacena en el hash %f_archivos los archivos seleccionados para filtrar.
# USA: $rModo, $g, %archivos.
# CREA / ACTUALIZA: %f_archivos.
sub obtenerFiltrosDeArchivo(){
	imprimirArchivosDisponibles();
	# Si el modo de filtado es por archivo, sólo se permite elegir uno.
	# (sólo modo -r)
	if($rModo eq "a"){
		print("Ingrese un nombre de archivo: \n");
	# En los otros dos modos se pueden elegir más de un patrón.
	}
	else{
		print("Ingrese nombres de archivo para filtrar; \n");
		print("ingrese * para agregar todos los archivos al filtro; \n");
		print("ingrese entrar para terminar.\n");
	}

	my $finDeIngreso = 0;
	local $agregados = 0;
	while(!$finDeIngreso){
		chomp(my $archivo = <STDIN>);
		# Sólo se permite salir con entrar cuando:
		#	- el modo es -g.
		# 	- el modo es -r y se agregaron archivos.
		if(($archivo eq "") && ($g || $agregados)){
			$finDeIngreso = 1;
		}
		# Se permite agregar a todos los archivos cuando el modo no es "a".
		elsif(($archivo eq "*") && ($rModo ne "a")){
			foreach(keys(%archivos)){
				$f_archivos{$_} = 0;
			}
			$agregados = 1;
		}
		# Si el archivo ya está en el filtro se lo elimina.
		elsif(exists $f_archivos{$archivo}){
			delete($f_archivos{$archivo});
			print("Se ha eliminado el archivo seleccionado. \n");
			if(scalar(keys(%f_archivos)) == 0){
				$agregados = 0;
			}
		}
		# Si el archivo existe y no está en el filtro se lo agrega.
		elsif(exists $archivos{$archivo}){
			$f_archivos{$archivo} = 0;
			# El modo -r "a" sólo permite agregar un archivo.
			if($rModo eq "a"){
				$finDeIngreso = 1;
			}
			$agregados = 1;
		}
		else{
			print("Archivo especificado inválido. Seleccione nuevamente.\n");
		}
	}
}


# Guía al usuario en el ingreso de números de ciclo para filtrar los resultados. 
# Almacena en el hash %f_ciclos los archivos seleccionados para filtrar.
# USA: $rModo, $g, $ultimoCiclo.
# CREA / ACTUALIZA: %f_ciclos.
sub obtenerFiltrosDeCiclo(){
	print("Ultimo ciclo procesado: \n\t $ultimoCiclo \n");
	# Si el modo de filtado es por ciclo, sólo se permite elegir uno.
	if($rModo eq "c"){
		print("Ingrese un número de ciclo: \n");
	}
	# En los otros dos modos se pueden elegir más de un ciclo.
	else{
		print("Ingrese números de ciclo para filtrar; \n");
		print("ingrese r para determinar un rango de ciclos; \n");
		print("ingrese * para agregar todos los ciclos al filtro; \n");
		print("ingrese entrar para terminar. \n");
	}
	
	my $finDeIngreso = 0;
	local $agregados = 0;
	while(!$finDeIngreso){
		chomp(my $ciclo = <STDIN>);
		# Sólo se permite salir con entrar cuando:
		#	- el modo es -g.
		# 	- el modo es -r y se agregaron ciclos.
		if(($ciclo eq "") && ($g || $agregados)){
			$finDeIngreso = 1;
		}
		# Se permite agregar a un rango de ciclos cuando el modo no es "c".
		elsif(($ciclo eq "r") && ($rModo ne "c")){
			print("Ingrese el número menor del intervalo de rango de ciclos a filtrar. \n");
			my $min = ingresoNumerico();
			while($min >= $ultimoCiclo){
				print("Selección inválida. Ingrese nuevamente. \n");
				$min = ingresoNumerico();
			}
			print("Ingrese el número mayor del intervalo de rango de ciclos a filtrar. \n");
			my $max = ingresoNumerico();
			while(($max > $ultimoCiclo) && ($max <= $min)){
				print("Selección inválida. Ingrese nuevamente. \n");
				$gMax = ingresoNumerico();
			}
			for(my $i = $min; $i <= $max; $i++){
				$f_ciclos{$i} = 0;
			}
			$agregados = 1;
		}
		# Se permite agregar a todos los ciclos cuando el modo no es "c".
		elsif(($ciclo eq "*") && ($rModo ne "c")){
			for(my $i = 1; $i <= $ultimoCiclo; $i++){
				$f_ciclos{$i} = 0;
			}
			$agregados = 1;
		}
		# Si el ciclo ya está en el filtro se lo elimina.
		elsif(exists $f_ciclos{$ciclo}){
			delete($f_ciclos{$ciclo});
			print("Se ha eliminado el ciclo seleccionado. \n");
			if(scalar(keys(%f_ciclos)) == 0){
				$agregados = 0;
			}
		}
		# Verifica que la cadena ingresada sea numérica.
		elsif($ciclo =~ /^[0-9]+$/){
			if(($ciclo > $ultimoCiclo) || ($ciclo <= 0)){
				print("Ciclo especificado inválido. Seleccione nuevamente.\n");
			}
			else{
				$f_ciclos{$ciclo} = 0;
				# El modo -r "c" sólo permite seleccionar un ciclo.
				if($rModo eq "c"){
					$finDeIngreso = 1;
				}
				$agregados = 1;
			}
		}
		else{
			print("Ciclo especificado inválido. Seleccione nuevamente.\n");
		}
	}
}


# Guía al usuario en el ingreso de sistemas para filtrar los resultados. 
# Almacena en el hash %f_sistemas los sistemas seleccionados para filtrar.
# USA: %sistemas.
# CREA / ACTUALIZA: %f_sistemas.
sub obtenerFiltrosDeSistema(){
	imprimirSistemasDisponibles();
	print("Ingrese ID de sistemas para filtrar; \n");
	print("ingrese * para agregar todos los sistemas; \n");
	print("ingrese entrar para terminar. \n");	

	my $finDeIngreso = 0;
	while(!$finDeIngreso){
		chomp(my $sistema = <STDIN>);
		if($sistema eq ""){
			$finDeIngreso = 1;
		}
		if($sistema eq "*"){
			foreach(keys(%sistemas)){
				$f_sistemas{$_} = 0;
			}
		}
		elsif(exists $f_sistemas{$sistema}){
			delete($f_sistemas{$sistema});
			print("Se ha eliminado el sistema seleccionado.\n");
		}
		elsif(exists $sistemas{$sistema}){
			$f_sistemas{$sistema} = 0;
		}
		else{
			print("Sistema especificado inválido. Seleccione nuevamente.\n");
		}
	}
}


# *************************************************************
# 	Funciones auxiliares relacionadas a la presentación
#	de resultados encontrados.
# *************************************************************

# Obtiene del archivo de configuración el último descriptor de informe 
# utilizado y actualiza el valor en el archivo.
# CREA: $ultimaSec.
sub obtenerNumeroDeInforme(){
	# Verifica la existencia del archivo de configuración.
	if(-e $ARCHCONF){
		open(CONFIG, "< $ARCHCONF") or die
			"No se pudo abrir archivo de configuraciones.\n";
		my @archConfig;
	}
	
	# Busca el registro SECUENCIA1 que almacena el último ciclo.
	# Además, graba el contenido del archivo de configuración a una lista.
	while(my $linea = <CONFIG>){
		if($linea =~ /^SECUENCIA1=(.*)$/){
			$ultimaSec = $1;
			last;
		}
		else{
			push(@archConfig, $linea);	
		}
	}

	# Reemplaza la línea de SECUENCIA.
	my $secNueva = $ultimaSec + 1;
	my $nuevaLinea = "SECUENCIA1=" . $secNueva . "\n";
	push(@archConfig, $nuevaLinea);
	while($linea = <CONFIG>){
		push(@archConfig, $linea);
	}
	close(CONFIG);
	
	# Y graba la lista.
	open(CONFIG, "> $ARCHCONF") or die
			"No se pudo guardar archvio de configuranciones.\n";
	print CONFIG @archConfig;
	close(CONFIG);
}


# Dados los hashes de los filtros con las ocurrencias como valores,
# crea un hash con todos los resultados.
# USA: %f_patrones, %f_archivos, %f_ciclos, %f_sistemas
# CREA: %filtrosPorOcurrencias.
sub unificarFiltros(){
	foreach my $clave (keys %f_patrones){
		my $claveNueva = "p" . $clave;
		$filtrosPorOcurrencias{$claveNueva} = $f_patrones{$clave};
	}
	foreach my $clave (keys %f_archivos){
		$claveNueva = "a" . $clave;
		$filtrosPorOcurrencias{$claveNueva} = $f_archivos{$clave};
	}
	foreach my $clave (keys %f_ciclos){
		$claveNueva = "c" . $clave;
		$filtrosPorOcurrencias{$claveNueva} = $f_ciclos{$clave};
	}
	foreach my $clave (keys %f_sistemas){
		$claveNueva = "s" . $clave;
		$filtrosPorOcurrencias{$claveNueva} = $f_sistemas{$clave};
	}
}


# Imprime por pantalla y también a archivo INFORME si corresponde.
# USA: INFORME, $x.
sub imprimirInforme($){
	if($x && $v){
		print INFORME ($_[0]);
	}
	print($_[0]);
}


# Imprime el tipo de filtro que fue leído.
# USA: $1.
sub imprimirTipo(){ 
	if($1 eq "a"){
		imprimirInforme("Archivo ");
	}
	elsif($1 eq "c"){
		imprimirInforme("Ciclo ");
	}
	elsif($1 eq "s"){
		imprimirInforme("Sistema ");
	}
	elsif($1 eq "p"){
		imprimirInforme("Patrón ");
	}
}


# Función principal del ListarW5 -r. Aplica los filtros obtenidos e
# imprime por pantalla los resultados.
# USA: $x, $f_patrones, $f_ciclos, $f_archivos.
sub rMostrarResultados($){
	if($x){
		my $nombreSalida = $REPODIR . "salida_" . $ultimaSec;
		open(INFORME, "> $nombreSalida") or die
			"No se pudo grabar archivo de informe. \n";
	}
	imprimirInforme("W-FIVE: SISTEMA DE CONSULTAS \n");
	imprimirInforme("Consulta de resultados detallados. \n \n");

	# Imprime los filtros usados.
	$v = 1;
	imprimirInforme("Filtros usados: \n");	
	imprimirPatronesFiltrados();
	imprimirCiclosFiltrados();
	imprimirArchivosFiltrados();
	imprimirInforme("\n\n");

	# Verifico si hay registros para listar.
	my $vacio = 1;

	my @listaDePatrones = keys(%f_patrones);
	foreach(@listaDePatrones){
		# Abre cada archivo de patrón que esté en el filtro.
		my $resultados = $PROCDIR . "resultados." . $_;
		if(-e $resultados){
			open(RESULTADOS, "< $resultados") or die 
				"No se pudo abrir archivo de resultados.\n";
		}
		else{
			`$LOGGER_EXE -e -c=124 -l=$comando_log`; 
			next;
		}
		# Puede que el registro sea de varias líneas, sin embargo la primera
		# es siempre de la forma NUMDECICLO+-#-+NOMARCHIVO+-#-+NREG+-#-+RESULTADO
		# La variable lineaNueva se activa cuando se encuentra un registro que
		# cumple todas las condiciones pedidas y se puede extender.
		my $lineaNueva = 0;
		while(my $linea = <RESULTADOS>){
			if($linea =~ /^([0-9]+)\+-#-\+(.+)\+-#-\+[0-9]+\+-#-\+(.+)$/){
				# regexp: 	$1 = número de ciclo, $2 = nombre de archivo
				#			$3 = mensaje de error.
				if((exists $f_ciclos{$1}) && (exists $f_archivos{$2})){
					$vacio = 0;
					imprimirInforme("$3 \n");
					$lineaNueva = 1;
				}
				else{
					$lineaNueva = 0;
				}
			}
			elsif($lineaNueva){
				imprimirInforme("$linea \n");
			}
		}	
		close(RESULTADOS);
	}

	if($vacio){
		imprimirInforme("No se encontraron resultados para los filtros especificados. \n");
	}

	if($x){
		close(INFORME);
	}
}


# Función principal de ListarW5 -g. Aplica los filtros obtenidos
# e imprime por pantalla los resutados.
# USA: $x, $f_archivos, $f_ciclos, $f_sistemas, $f_patrones.
sub gMostrarResultados($){
	if($x){
		my $nombreSalida = $REPODIR . "salida_" . $ultimaSec;
		open(INFORME, "> $nombreSalida") or die
			"No se pudo grabar archivo de informe. \n";
	}
	imprimirInforme("W-FIVE: SISTEMA DE CONSULTAS \n");
	imprimirInforme("Consulta de resultados globales. \n \n");

	# Verifico que haya filtros activados.
	if(!scalar(keys(%f_archivos)) && !scalar(keys(%f_ciclos)) &&
	   !scalar(keys(%f_sistemas)) && !scalar(keys(%f_patrones)))
	{
		imprimirInforme("No se especificaron filtros. \n");
		if($x){
			close(INFORME);
		}
		exit 0;
	}

	# Imprime los filtros usados.
	$v = 1;
	imprimirInforme("Filtros usados: \n");	
	imprimirPatronesFiltrados();
	imprimirCiclosFiltrados();
	imprimirArchivosFiltrados();
	imprimirSistemasFiltrados();
	imprimirInforme("\n\n");

	# Leo uno por uno todos los archivos de resultados globales.
	my @listaDePatrones = keys(%patrones);
	foreach(@listaDePatrones){
		my $rglobales = $PROCDIR . "rglobales." . $_;
		if(-e $rglobales){
			open(RESULTADOS, "< $rglobales") or die 
				"No se pudo abrir archivo de resultados.\n";
		}
		else{
			`$LOGGER_EXE -e -c=124 -l=$comando_log`; 
			next;
		}
	
		# Guardo la info en los hashes de filtro, actualizando cantidad
		# de hallazgos.
		while(my $linea = <RESULTADOS>){
			if($linea =~ /^([0-9]+),(.+)_(.+),([0-9]+),.+,.+,.+,.+$/){
				# expreg: 	$1 = nro ciclo; $2 = nombre de sistema,
				#			$3 = fecha de log; $4 = cantidad de hallazgos.
				if(exists $f_patrones{$_}){
					$f_patrones{$_} += $4;
				}
				$nombreDeArchivo = $2 . "_" . $3;
				if(exists $f_archivos{$nombreDeArchivo}){
					$f_archivos{$nombreDeArchivo} += $4;
				}
				if(exists $f_ciclos{$1}){
					$f_ciclos{$1} += $4;
				}
				if(exists $f_sistemas{$2}){
					$f_sistemas{$2} += $4;
				}
			}
		}
	}

	# Ordeno la salida.
	unificarFiltros();
	foreach $filtro (sort{$filtrosPorOcurrencias{$a} <=> $filtrosPorOcurrencias{$b}} 
		keys %filtrosPorOcurrencias)
	{
		push(@valores, $filtrosPorOcurrencias{$filtro});
		push(@claves, $filtro);
	}
	
	# Variable usada para imprimir que no se encontraron resultados.
	$vacio = 1;

	# Y muestro según corresponda.
	my $tamFiltros = scalar(@claves);
	if($gModo eq "r"){
		imprimirInforme("Consultas de filtros con entre $gMin y $gMax hallazgos. \n");
		# Al tener la salida ordenada no hace falta iterar sobre todo el vector.
		for(my $i = 0; ($i < $tamFiltros) && ($valores[$i] <= $gMax); $i++){
			$claves[$i] =~ /^(.)(.*)$/;
			if($valores[$i] >= $gMin){
				$vacio = 0;
				imprimirTipo();
				imprimirInforme("$2 \t $valores[$i] ");
				if($valores[$i] == 1){
					imprimirInforme("hallazgo. \n");
				}
				else{
					imprimirInforme("hallazgos. \n");
				}
			}
		}
	}
	elsif($gModo eq "c"){
		imprimirInforme("Consultas de filtros con $gCantidad de hallazgos. \n");
		for(my $i = 0; ($i < $tamFiltros) && ($valores[$i] < $gCantidad); $i++){
			$claves[$i] =~ /^(.)(.*)$/;
			if($valores[$i] == $gCantidad){
				$vacio = 0;
				imprimirTipo();
				imprimirInforme("$2 \t $valores[$i] ");
				if($valores[$i] == 1){
					imprimirInforme("hallazgo. \n");
				}
				else{
					imprimirInforme("hallazgos. \n");
				}
			}
		}		
	}
	else{
		if($gModo eq "e"){
			imprimirInforme("Consultas por menor cantidad de hallazgos. \n");	
		}
		elsif($gModo eq "a"){
			imprimirInforme("Consultas por mayor cantidad de hallazgos. \n");
			@claves = reverse(@claves);
			@valores = reverse(@valores);
		}
		for(my $i = 0; ($i < $tamFiltros) && ($i < $gCantidad); $i++){
			$vacio = 0;
			$claves[$i] =~ /^(.)(.*)$/;
			imprimirTipo();
			imprimirInforme("$2 \t $valores[$i] ");
			if($valores[$i] == 1){
				imprimirInforme("hallazgo. \n");
			}
			else{
				imprimirInforme("hallazgos. \n");
			}
		}
	}

	if($vacio){
		imprimirInforme("No se encontraron resultados para los filtros especificados. \n");
	}

	if($x){
		close(INFORME);
	}
}


# *************************************************************
# 	Funciones auxiliares relacionadas a la selección de  
#	filtros para resultados globales y detallados.
# *************************************************************

# Ejecutado sólo si el usuario invoca a la aplicación con la opción -r.
# Guía al usuario en el ingreso de filtros para listar los resultados 
# de los archivos de resultados detallados "resultados.PAT_ID".
# CREA: $p, $c, $a.
sub rSeleccionarFiltros(){
	# Itera hasta que el usuario seleccione una opción válida.
	my $selvalida = 0;
	print("Selección de filtros: \n");
	print("seleccione p para listar por patrón; \n");
	print("seleccione c para listar por ciclo; \n");
	print("seleccione a para listar por archivo. \n");

	while(!$selvalida){
		print("Ingrese una opción: [p, c, a] \n");
		chomp($rModo = <STDIN>);
	
		if($rModo eq "p"){
			$selvalida = 1;
			obtenerFiltrosDePatron();
			obtenerFiltrosDeCiclo();
			obtenerFiltrosDeArchivo();
		}
		
		elsif($rModo eq "c"){
			$selvalida = 1;	
			obtenerFiltrosDeCiclo();
			obtenerFiltrosDePatron();
			obtenerFiltrosDeArchivo();
		}
		
		elsif($rModo eq "a"){
			$selvalida = 1;
			obtenerFiltrosDeArchivo();
			obtenerFiltrosDePatron();
		}

		else{
			print("Selección inválida, intente nuevamente.\n");
		}
	}
}


# Ejecutado sólo si el usuario invoca a la aplicación con la opción -g.
# Selecciona los filtros para la consulta de hallazgos de resultados globales.
sub gSeleccionarFiltros(){
	my $finDeIngreso = 0;
	while(!$finDeIngreso){
		print("Selección de filtros: \n");
		print("seleccione p para agregar filtros por patrón; \n");
		print("seleccione c para agregar filtros por ciclo; \n");
		print("seleccione a para agregar filtros por archivo; \n");
		print("seleccione s para agregar filtros por sistema; \n");
		print("seleccione v para ver filtros agregados hasta ahora; \n");
		print("seleccione entrar para terminar de filtrar. \n");
		print("Ingrese una opción: [p, c, a, s, f, v, entrar] \n");
		chomp(my $filtro = <STDIN>);
	
		if($filtro eq "p"){
			obtenerFiltrosDePatron();
		}
		
		elsif($filtro eq "c"){
			obtenerFiltrosDeCiclo();
		}
		
		elsif($filtro eq "a"){
			obtenerFiltrosDeArchivo();
		}

		elsif($filtro eq "s"){
			obtenerFiltrosDeSistema();
		}

		elsif($filtro eq "v"){
			imprimirPatronesFiltrados();
			imprimirCiclosFiltrados();
			imprimirArchivosFiltrados();
			imprimirSistemasFiltrados();
			imprimirInforme("\n");
		}

		elsif($filtro eq ""){
			$finDeIngreso = 1;
		}
	
		else{
			print("Selección inválida, intente nuevamente.\n");
		}
	}
}


# Permite al usuario seleccionar el modo de consulta para resultados globales.
# CREA: $gModo = [aen], $gCantidad (si $gModo es a o e).
sub gSeleccionarModo(){
	print("Selección de modo: \n");
	print("seleccione a para mostrar mayor cantidad de hallazgos; \n");
	print("seleccione e para mostrar menor cantidad de hallazgos; \n");
	print("seleccione c para mostrar una cantidad específica de hallazgos; \n");
	print("seleccione r para mostrar un rango de hallazgos. \n");
	my $selValida = 0;
	while(!$selValida){
		print("Ingrese una opción: [a, e, c, r] \n");
		chomp($gModo = <STDIN>);
		if($gModo =~ /^[aerc]$/){
			$selValida = 1;
		} 
		else{
			print("Selección inválida. Ingrese nuevamente. \n");
		}
	}

	if($gModo eq "r"){
		print("Ingrese el número mínimo de hallazgos a mostrar. \n");
		$gMin = ingresoNumerico();
		print("Ingrese el número máximo de hallazgos a mostrar. \n");
		$gMax = ingresoNumerico();
		while($gMax <= $gMin){
			print("Selección inválida. Ingrese nuevamente. \n");
			$gMax = ingresoNumerico();
		}
	}
	elsif($gModo eq "c"){
		print("Ingrese el número de hallazgos a mostrar. \n");
		$gCantidad = ingresoNumerico();
	}
	else{
		print("Ingrese la cantidad de resultados que desea mostrar. \n");
		$gCantidad = ingresoNumerico();
	}
}


# Imprime la ayuda de la función.
sub mostrarAyuda(){
	print("ayuda!!\n");
}

# Obtiene de ARGV los argumentos de llamado.
# CREA: $g, $x, $r.
sub obtenerArgumentos(){
	foreach(@ARGV){
		if($_ eq "-h"){
			mostrarAyuda();	
			exit 0;
		}
		
		elsif($_ eq "-g"){
			$g = 1;
			$rModo = 0;
			$v = 1;
		}
		
		elsif($_ eq "-r"){
			$r = 1;
			$gModo = 0;
			$gCantidad = -1;
			$v = 1;
		}

		elsif($_ eq "-x"){
			obtenerNumeroDeInforme();
			$x = 1;
		}
	}
	
	if($r && $g){
		print "Error: -g y -r son mutuamente excluyentes. Ver ayuda.\n";
		return -1;
	}
}

	
sub main(){
	obtenerArgumentos();
	obtenerPatronesValidos();
	obtenerArchivosValidos();
	obtenerUltimoCiclo();
	if($r){
		`$LOGGER_EXE -m=\"Se inicia la consulta de resultados detallados..\" -i -l=$comando_log`;
		rSeleccionarFiltros();
		rMostrarResultados($x);
		`$LOGGER_EXE -m=\"Se completo la consulta de resultados globales exitosamente.\" -i -l=$comando_log`;
	} 
	elsif($g){
		`$LOGGER_EXE-m=\"Se inicia la consulta de resultados globales..\" -i -l=$comando_log`;
		obtenerSistemasValidos();
		gSeleccionarModo();
		gSeleccionarFiltros();
		gMostrarResultados($x);
		`$LOGGER_EXE -m=\"Se completo la consulta de resultados globales exitosamente.\" -i -l=$comando_log`;
	}
	exit 0;
}


main();


==================================================================================================




